Celestin Apprentice 7/Apprentice-Release7.iso/Environments/Clean 1.2.4/Clean Help/Clean Help.rsrc/STR#_10000.txt

Text File | 1997-06-20 | 6.5 KB | 419 lines




ñTable of Contents








































‚åò

‚áß

‚å•

⌃

























!

"

#

$

%

&

'

(

)

*

+

,

-

.

/

0

1

2

3

4

5

6

7

8

9

:

;

<

=

>

?

@

A

B

C

D

E

F

G

H








»The Concurrent Clean Program Development System








© 1987-1997






Computing Science Institute




University of Nijmegen




Nijmegen - The Netherlands








Version 1.2 - January1997









N.B. This Help file can be printed by choosing





Print... from the File menu (see also the entry Help).




Concurrent Clean 1.2 is a general purpose, higher order, pure and lazy

functional programming language that can be used for the development of

sequential, parallel or distributed executing real world applications. The

Concurrent Clean Programming Development System is a special

programming environment for Concurrent Clean. Concurrent Clean is

developed at the University of Nijmegen.





This Help file complements version 1.2 of Concurrent Clean and the

Concurrent Clean System. A description of the syntax and semantics of

Concurrent Clean 1.2 can be found in the following manual:





Concurrent Clean



- version 1.2 -



Reference Manual



Rinus Plasmeijer and Marko van Eekelen



University of Nijmegen



January 1997 (Draft Version)



Functional programming languages, Concurrent Clean (0.8) and its

implementation on sequential and parallel machine architectures are

explained in detail in the following textbook:





Functional Programming and Parallel Graph Rewriting



Rinus Plasmeijer and Marko van Eekelen



Addison-Wesley Publishing Company



1993



ISBN 0-201-41663-8



For more background information we refer to the Bibliography.








ñ1. Concurrent Clean version 1.2



The most important features of Concurrent Clean are:





• Clean is a lazy, pure, higher order functional programming language

with explicit graph rewriting semantics; one can explicitly define the

sharing of structures (cyclic structures as well) in the language;



• Although Clean is by default a lazy language one can smoothly turn it

into a strict language to obtain optimal time/space behaviour: functions

can be defined lazy as well as (partially) strict in their arguments; any

(recursive) data structure can be defined lazy as well as (partially) strict

in any of its arguments;



• Clean is a strongly typed language based on an extension of the

well-known Milner/Hindley type inferencing scheme (Milner 1978;

Hindley 1969) including the common polymorphic types, abstract types,

algebraic types, and synonym types extended with a restricted facility

for existentially quantified types;



• Type classes and type constructor classes are provided to make

overloaded use of functions and operators possible.



• Clean offers the following predefined types: integers, reals, booleans,

characters, strings, lists, tuples, records, arrays and files;



• Clean's key feature is a polymorphic uniqueness type inferencing

system, a special extension of the Milner/Hindley type inferencing

system allowing a refined control over the single threaded use of objects;

with this uniqueness type system one can influence the time and space

behaviour of programs; it can be used to incorporate destructive updates

of objects within a pure functional framework, it allows destructive

transformation of state information, it enables efficient interfacing to the

non-functional world (to C but also to I/O systems like X-Windows)

offering direct access to file systems and operating systems;



• Clean offers a sophisticated I/O library with which window based

interactive applications (and the handling of menus, dialogues, windows,

mouse, keyboard, timers and events raised by sub-applications) can be

specified compactly and elegantly on a very high level of abstraction;



• Specifications of window based interactive applications can be combined

such that one can create several applications (sub-applications or

light-weight processes) inside one Clean application. Automatic switching

between these sub-applications is handled in a similar way as under a

multi-finder (all low level event handling for updating windows and

switching between menus is done automatically); sub-applications can

exchange information with each other (via files, via clipboard copy-paste

like actions using shared state components, via asynchronous message

passing) but also with other independently programmed (Clean or other)

applications running on the same or even on a different host system;



• Sub-applications can be created on other machines which means that one

can define distributed window based interactive Clean applications

communicating e.g. via (a)synchronous message passing and remote

procedure calls across a local area network;



• Dynamic process creation is possible; processes can run interleaved or

in parallel; arbitrary process topologies (for instance cyclic structures)

can be defined; the interprocess communication is synchronous and is

handled automatically simply when one function demands the evaluation of

its arguments being calculated by another process possibly executing on

another processor;



• Clean is a modular language allowing separate compilation of modules;

one defines implementation modules and definition modules; there is a

facility to implicitly and explicitly import definitions from other modules;

Clean includes a huge collection of predefined modules (standard libraries)

for process creation, I/O and basic operations on objects of predefined

types;



• Due to the strong typing of Clean and the obligation to initialize all

objects being created run-time errors can only occur in a very limited

number of cases: when partial functions are called with arguments out of

their domain (e.g. dividing by zero), when arrays are accessed with

indices out-of-range and when not enough memory is assigned to a Clean

application;



• Clean 1.2 is supported on several platforms (see "Concurrent Clean:

Language Report" for an overview).